# frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/version"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/arithmetic"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/arithmetic_evaluator"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/base"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/loader"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/game_system/DiceBot"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/common_command"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/preprocessor"
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/arithmetic/node"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/arithmetic/parser"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module BCDice
          
        
      
        

          

            
              1
            

            
              
            

              module Arithmetic
          
        
      
        

          

            
              1
            

            
              
            

                class << self
          
        
      
        

          

            

            
              
            

                  # 四則演算を評価する
          
        
      
        

          

            

            
              
            

                  #
          
        
      
        

          

            

            
              
            

                  # @param source [String]
          
        
      
        

          

            

            
              
            

                  # @param round_type [Symbol]
          
        
      
        

          

            

            
              
            

                  # @return [Integer, nil] パースできない式やゼロ除算が発生した場合にはnilを返す
          
        
      
        

          

            
              1
            

            
              
            

                  def eval(source, round_type)
          
        
      
        

          

            
              3530
            

            
              
            

                    node = Parser.parse(source)
          
        
      
        

          

            
              3530
            

            
              
                
                  then: 3054
                
              
                
                  else: 476
                
              
            

                    node&.eval(round_type)
          
        
      
        

          

            

            
              
            

                  rescue ZeroDivisionError
          
        
      
        

          

            
              2
            

            
              
            

                    nil
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module BCDice
          
        
      
        

          

            
              1
            

            
              
            

              module Arithmetic
          
        
      
        

          

            
              1
            

            
              
            

                module Node
          
        
      
        

          

            
              1
            

            
              
            

                  class BinaryOp
          
        
      
        

          

            
              1
            

            
              
            

                    def initialize(lhs, op, rhs)
          
        
      
        

          

            
              1355
            

            
              
            

                      @lhs = lhs
          
        
      
        

          

            
              1355
            

            
              
            

                      @op = op
          
        
      
        

          

            
              1355
            

            
              
            

                      @rhs = rhs
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    def eval(round_type)
          
        
      
        

          

            
              1190
            

            
              
            

                      l = @lhs.eval(round_type)
          
        
      
        

          

            
              1189
            

            
              
            

                      r = @rhs.eval(round_type)
          
        
      
        

          

            
              1186
            

            
              
            

                      l.send(@op, r)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # @return [String] メッセージへの出力
          
        
      
        

          

            
              1
            

            
              
            

                    def output
          
        
      
        

          

            
              77
            

            
              
            

                      "#{@lhs.output}#{@op}#{@rhs.output}"
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # @return [String] ノードのS式
          
        
      
        

          

            
              1
            

            
              
            

                    def s_exp
          
        
      
        

          

            

            
              
            

                      "(#{op_for_s_exp} #{@lhs.s_exp} #{@rhs.s_exp})"
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # @return [String] S式で使う演算子の表現
          
        
      
        

          

            
              1
            

            
              
            

                    def op_for_s_exp
          
        
      
        

          

            

            
              
            

                      @op
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 除算ノードの基底クラス
          
        
      
        

          

            

            
              
            

                  #
          
        
      
        

          

            

            
              
            

                  # 定数 +ROUNDING_METHOD+ で端数処理方法を示す記号
          
        
      
        

          

            

            
              
            

                  # ( +'U'+, +'R'+, +''+ ) を定義すること。
          
        
      
        

          

            

            
              
            

                  # また、除算および端数処理を行う +divide_and_round+ メソッドを実装すること。
          
        
      
        

          

            
              1
            

            
              
            

                  class DivideBase < BinaryOp
          
        
      
        

          

            

            
              
            

                    # ノードを初期化する
          
        
      
        

          

            

            
              
            

                    # @param [Object] lhs 左のオペランドのノード
          
        
      
        

          

            

            
              
            

                    # @param [Object] rhs 右のオペランドのノード
          
        
      
        

          

            
              1
            

            
              
            

                    def initialize(lhs, rhs)
          
        
      
        

          

            
              126
            

            
              
            

                      super(lhs, :/, rhs)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    def eval(round_type)
          
        
      
        

          

            
              114
            

            
              
            

                      l = @lhs.eval(round_type)
          
        
      
        

          

            
              114
            

            
              
            

                      r = @rhs.eval(round_type)
          
        
      
        

          

            
              114
            

            
              
            

                      divide_and_round(l, r, round_type)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # メッセージへの出力を返す
          
        
      
        

          

            

            
              
            

                    #
          
        
      
        

          

            

            
              
            

                    # 通常の結果の末尾に、端数処理方法を示す記号を付加する。
          
        
      
        

          

            

            
              
            

                    #
          
        
      
        

          

            

            
              
            

                    # @return [String]
          
        
      
        

          

            
              1
            

            
              
            

                    def output
          
        
      
        

          

            
              31
            

            
              
            

                      "#{super}#{rounding_method}"
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # 端数処理方法を示す記号を返す
          
        
      
        

          

            

            
              
            

                    # @return [String]
          
        
      
        

          

            
              1
            

            
              
            

                    def rounding_method
          
        
      
        

          

            
              31
            

            
              
            

                      self.class::ROUNDING_METHOD
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # S式で使う演算子の表現を返す
          
        
      
        

          

            

            
              
            

                    # @return [String]
          
        
      
        

          

            
              1
            

            
              
            

                    def op_for_s_exp
          
        
      
        

          

            

            
              
            

                      "#{@op}#{rounding_method}"
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # 除算および端数処理を行う
          
        
      
        

          

            

            
              
            

                    # @param [Integer] _dividend 被除数
          
        
      
        

          

            

            
              
            

                    # @param [Integer] _divisor 除数（0以外）
          
        
      
        

          

            

            
              
            

                    # @param [Symbol] _round_type ゲームシステムの端数処理設定
          
        
      
        

          

            

            
              
            

                    # @return [Integer]
          
        
      
        

          

            
              1
            

            
              
            

                    def divide_and_round(_dividend, _divisor, _round_type)
          
        
      
        

          

            

            
              
            

                      raise NotImplementedError
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 除算（端数処理はゲームシステム依存）のノード
          
        
      
        

          

            
              1
            

            
              
            

                  class DivideWithGameSystemDefault < DivideBase
          
        
      
        

          

            

            
              
            

                    # 端数処理方法を示す記号
          
        
      
        

          

            
              1
            

            
              
            

                    ROUNDING_METHOD = ""
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # 除算および端数処理を行う
          
        
      
        

          

            

            
              
            

                    # @param [Integer] dividend 被除数
          
        
      
        

          

            

            
              
            

                    # @param [Integer] divisor 除数（0以外）
          
        
      
        

          

            

            
              
            

                    # @param [Symbol] round_type ゲームシステムの端数処理設定
          
        
      
        

          

            

            
              
            

                    # @return [Integer]
          
        
      
        

          

            
              1
            

            
              
            

                    def divide_and_round(dividend, divisor, round_type)
          
        
      
        

          

            
              96
            

            
              
            

                      case round_type
          
        
      
        

          

            

            
              
                
                  when: 9
                
              
            

                      when RoundType::CEIL
          
        
      
        

          

            
              9
            

            
              
            

                        (dividend.to_f / divisor).ceil
          
        
      
        

          

            

            
              
                
                  when: 8
                
              
            

                      when RoundType::ROUND
          
        
      
        

          

            
              8
            

            
              
            

                        (dividend.to_f / divisor).round
          
        
      
        

          

            

            
              
                
                  else: 79
                
              
            

                      else # RoundType::FLOOR
          
        
      
        

          

            
              79
            

            
              
            

                        dividend / divisor
          
        
      
        

          

            

            
              
            

                      end
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 除算（切り上げ）のノード
          
        
      
        

          

            
              1
            

            
              
            

                  class DivideWithCeil < DivideBase
          
        
      
        

          

            

            
              
            

                    # 端数処理方法を示す記号
          
        
      
        

          

            
              1
            

            
              
            

                    ROUNDING_METHOD = "C"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # 除算および端数処理を行う
          
        
      
        

          

            

            
              
            

                    # @param [Integer] dividend 被除数
          
        
      
        

          

            

            
              
            

                    # @param [Integer] divisor 除数（0以外）
          
        
      
        

          

            

            
              
            

                    # @param [Symbol] _round_type ゲームシステムの端数処理設定
          
        
      
        

          

            

            
              
            

                    # @return [Integer]
          
        
      
        

          

            
              1
            

            
              
            

                    def divide_and_round(dividend, divisor, _round_type)
          
        
      
        

          

            
              12
            

            
              
            

                      (dividend.to_f / divisor).ceil
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 除算（四捨五入）のノード
          
        
      
        

          

            
              1
            

            
              
            

                  class DivideWithRound < DivideBase
          
        
      
        

          

            

            
              
            

                    # 端数処理方法を示す記号
          
        
      
        

          

            
              1
            

            
              
            

                    ROUNDING_METHOD = "R"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # 除算および端数処理を行う
          
        
      
        

          

            

            
              
            

                    # @param [Integer] dividend 被除数
          
        
      
        

          

            

            
              
            

                    # @param [Integer] divisor 除数（0以外）
          
        
      
        

          

            

            
              
            

                    # @param [Symbol] _round_type ゲームシステムの端数処理設定
          
        
      
        

          

            

            
              
            

                    # @return [Integer]
          
        
      
        

          

            
              1
            

            
              
            

                    def divide_and_round(dividend, divisor, _round_type)
          
        
      
        

          

            
              3
            

            
              
            

                      (dividend.to_f / divisor).round
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 除算（切り捨て）のノード
          
        
      
        

          

            
              1
            

            
              
            

                  class DivideWithFloor < DivideBase
          
        
      
        

          

            

            
              
            

                    # 端数処理方法を示す記号
          
        
      
        

          

            
              1
            

            
              
            

                    ROUNDING_METHOD = "F"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # 除算および端数処理を行う
          
        
      
        

          

            

            
              
            

                    # @param [Integer] dividend 被除数
          
        
      
        

          

            

            
              
            

                    # @param [Integer] divisor 除数（0以外）
          
        
      
        

          

            

            
              
            

                    # @param [Symbol] _round_type ゲームシステムの端数処理設定
          
        
      
        

          

            

            
              
            

                    # @return [Integer]
          
        
      
        

          

            
              1
            

            
              
            

                    def divide_and_round(dividend, divisor, _round_type)
          
        
      
        

          

            
              3
            

            
              
            

                      dividend / divisor
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  class Negative
          
        
      
        

          

            
              1
            

            
              
            

                    def initialize(body)
          
        
      
        

          

            
              494
            

            
              
            

                      @body = body
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    def eval(round_type)
          
        
      
        

          

            
              494
            

            
              
            

                      -@body.eval(round_type)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # @return [String] メッセージへの出力
          
        
      
        

          

            
              1
            

            
              
            

                    def output
          
        
      
        

          

            
              24
            

            
              
            

                      "-#{@body.output}"
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    def s_exp
          
        
      
        

          

            

            
              
            

                      "(- #{@body.s_exp})"
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # カッコで式をまとめるノード
          
        
      
        

          

            
              1
            

            
              
            

                  class Parenthesis
          
        
      
        

          

            

            
              
            

                    # @param expr [Object] カッコ内のノード
          
        
      
        

          

            
              1
            

            
              
            

                    def initialize(expr)
          
        
      
        

          

            
              46
            

            
              
            

                      @expr = expr
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # @param round_type [Symbol] 端数処理方法
          
        
      
        

          

            

            
              
            

                    # @return [Integer] 評価結果
          
        
      
        

          

            
              1
            

            
              
            

                    def eval(round_type)
          
        
      
        

          

            
              46
            

            
              
            

                      @expr.eval(round_type)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # @return [String] メッセージへの出力
          
        
      
        

          

            
              1
            

            
              
            

                    def output
          
        
      
        

          

            
              46
            

            
              
            

                      "(#{@expr.output})"
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # @return [String] S式
          
        
      
        

          

            
              1
            

            
              
            

                    def s_exp
          
        
      
        

          

            

            
              
            

                      "(Parenthesis #{@expr.s_exp})"
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  class Number
          
        
      
        

          

            
              1
            

            
              
            

                    def initialize(value)
          
        
      
        

          

            
              10901
            

            
              
            

                      @value = value
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    def eval(_round_type)
          
        
      
        

          

            
              10321
            

            
              
            

                      @value
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # @return [String] メッセージへの出力
          
        
      
        

          

            
              1
            

            
              
            

                    def output
          
        
      
        

          

            
              222
            

            
              
            

                      @value.to_s
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    alias s_exp output
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # DO NOT MODIFY!!!!
          
        
      
        

          

            

            
              
            

            # This file is automatically generated by Racc 1.7.3
          
        
      
        

          

            

            
              
            

            # from Racc grammar file "parser.y".
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require 'racc/parser.rb'
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/common_command/lexer"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/arithmetic/node"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module BCDice
          
        
      
        

          

            
              1
            

            
              
            

              module Arithmetic
          
        
      
        

          

            
              1
            

            
              
            

                class Parser < Racc::Parser
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def self.parse(source)
          
        
      
        

          

            
              3530
            

            
              
            

              new.parse(source)
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def parse(source)
          
        
      
        

          

            
              3530
            

            
              
            

              @lexer = BCDice::CommonCommand::Lexer.new(source)
          
        
      
        

          

            
              3530
            

            
              
            

              do_parse()
          
        
      
        

          

            

            
              
            

            rescue ParseError
          
        
      
        

          

            
              476
            

            
              
            

              nil
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def next_token
          
        
      
        

          

            
              10638
            

            
              
            

              @lexer.next_token
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            ##### State transition tables begin ###
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            racc_action_table = [
          
        
      
        

          

            

            
              
            

                 8,    17,     8,    12,    13,     4,     5,     4,     5,     7,
          
        
      
        

          

            

            
              
            

                 8,     7,     8,    12,    13,     4,     5,     4,     5,     7,
          
        
      
        

          

            

            
              
            

                 8,     7,     8,    12,    13,     4,     5,     4,     5,     7,
          
        
      
        

          

            

            
              
            

                 8,     7,     8,   nil,   nil,     4,     5,     4,     5,     7,
          
        
      
        

          

            

            
              
            

                 9,     7,   nil,   nil,    10,    11,   nil,    10,    11,    22,
          
        
      
        

          

            

            
              
            

                26,    24,    25,    27 ]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            racc_action_check = [
          
        
      
        

          

            

            
              
            

                 0,     9,     4,     2,     2,     0,     0,     4,     4,     0,
          
        
      
        

          

            

            
              
            

                 5,     4,     7,    18,    18,     5,     5,     7,     7,     5,
          
        
      
        

          

            

            
              
            

                10,     7,    11,    19,    19,    10,    10,    11,    11,    10,
          
        
      
        

          

            

            
              
            

                12,    11,    13,   nil,   nil,    12,    12,    13,    13,    12,
          
        
      
        

          

            

            
              
            

                 1,    13,   nil,   nil,    16,    16,   nil,     1,     1,    16,
          
        
      
        

          

            

            
              
            

                21,    21,    21,    21 ]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            racc_action_pointer = [
          
        
      
        

          

            

            
              
            

                -2,    40,    -6,   nil,     0,     8,   nil,    10,   nil,     1,
          
        
      
        

          

            

            
              
            

                18,    20,    28,    30,   nil,   nil,    37,   nil,     4,    14,
          
        
      
        

          

            

            
              
            

               nil,    47,   nil,   nil,   nil,   nil,   nil,   nil ]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            racc_action_default = [
          
        
      
        

          

            

            
              
            

               -17,   -17,    -3,    -6,   -17,   -17,   -14,   -17,   -16,   -17,
          
        
      
        

          

            

            
              
            

               -17,   -17,   -17,   -17,   -12,   -13,   -17,    28,    -1,    -2,
          
        
      
        

          

            

            
              
            

                -4,    -7,   -15,    -5,    -8,    -9,   -10,   -11 ]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            racc_goto_table = [
          
        
      
        

          

            

            
              
            

                14,    15,    23,     1,    18,    19,   nil,   nil,    20,    21,
          
        
      
        

          

            

            
              
            

                16 ]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            racc_goto_check = [
          
        
      
        

          

            

            
              
            

                 3,     3,     4,     1,     2,     2,   nil,   nil,     3,     3,
          
        
      
        

          

            

            
              
            

                 1 ]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            racc_goto_pointer = [
          
        
      
        

          

            

            
              
            

               nil,     3,    -6,    -4,   -19,   nil ]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            racc_goto_default = [
          
        
      
        

          

            

            
              
            

               nil,   nil,     2,     3,   nil,     6 ]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            racc_reduce_table = [
          
        
      
        

          

            

            
              
            

              0, 0, :racc_error,
          
        
      
        

          

            

            
              
            

              3, 14, :_reduce_1,
          
        
      
        

          

            

            
              
            

              3, 14, :_reduce_2,
          
        
      
        

          

            

            
              
            

              1, 14, :_reduce_none,
          
        
      
        

          

            

            
              
            

              3, 15, :_reduce_4,
          
        
      
        

          

            

            
              
            

              4, 15, :_reduce_5,
          
        
      
        

          

            

            
              
            

              1, 15, :_reduce_none,
          
        
      
        

          

            

            
              
            

              0, 17, :_reduce_7,
          
        
      
        

          

            

            
              
            

              1, 17, :_reduce_8,
          
        
      
        

          

            

            
              
            

              1, 17, :_reduce_9,
          
        
      
        

          

            

            
              
            

              1, 17, :_reduce_10,
          
        
      
        

          

            

            
              
            

              1, 17, :_reduce_11,
          
        
      
        

          

            

            
              
            

              2, 16, :_reduce_12,
          
        
      
        

          

            

            
              
            

              2, 16, :_reduce_13,
          
        
      
        

          

            

            
              
            

              1, 16, :_reduce_none,
          
        
      
        

          

            

            
              
            

              3, 18, :_reduce_15,
          
        
      
        

          

            

            
              
            

              1, 18, :_reduce_16 ]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            racc_reduce_n = 17
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            racc_shift_n = 28
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            racc_token_table = {
          
        
      
        

          

            

            
              
            

              false => 0,
          
        
      
        

          

            

            
              
            

              :error => 1,
          
        
      
        

          

            

            
              
            

              :NUMBER => 2,
          
        
      
        

          

            

            
              
            

              :R => 3,
          
        
      
        

          

            

            
              
            

              :U => 4,
          
        
      
        

          

            

            
              
            

              :C => 5,
          
        
      
        

          

            

            
              
            

              :F => 6,
          
        
      
        

          

            

            
              
            

              :PLUS => 7,
          
        
      
        

          

            

            
              
            

              :MINUS => 8,
          
        
      
        

          

            

            
              
            

              :ASTERISK => 9,
          
        
      
        

          

            

            
              
            

              :SLASH => 10,
          
        
      
        

          

            

            
              
            

              :PARENL => 11,
          
        
      
        

          

            

            
              
            

              :PARENR => 12 }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            racc_nt_base = 13
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            racc_use_result_var = true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            Racc_arg = [
          
        
      
        

          

            
              1
            

            
              
            

              racc_action_table,
          
        
      
        

          

            

            
              
            

              racc_action_check,
          
        
      
        

          

            

            
              
            

              racc_action_default,
          
        
      
        

          

            

            
              
            

              racc_action_pointer,
          
        
      
        

          

            

            
              
            

              racc_goto_table,
          
        
      
        

          

            

            
              
            

              racc_goto_check,
          
        
      
        

          

            

            
              
            

              racc_goto_default,
          
        
      
        

          

            

            
              
            

              racc_goto_pointer,
          
        
      
        

          

            

            
              
            

              racc_nt_base,
          
        
      
        

          

            

            
              
            

              racc_reduce_table,
          
        
      
        

          

            

            
              
            

              racc_token_table,
          
        
      
        

          

            

            
              
            

              racc_shift_n,
          
        
      
        

          

            

            
              
            

              racc_reduce_n,
          
        
      
        

          

            

            
              
            

              racc_use_result_var ]
          
        
      
        

          

            
              1
            

            
              
                
                  then: 1
                
              
                
                  else: 0
                
              
            

            Ractor.make_shareable(Racc_arg) if defined?(Ractor)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            Racc_token_to_s_table = [
          
        
      
        

          

            

            
              
            

              "$end",
          
        
      
        

          

            

            
              
            

              "error",
          
        
      
        

          

            

            
              
            

              "NUMBER",
          
        
      
        

          

            

            
              
            

              "R",
          
        
      
        

          

            

            
              
            

              "U",
          
        
      
        

          

            

            
              
            

              "C",
          
        
      
        

          

            

            
              
            

              "F",
          
        
      
        

          

            

            
              
            

              "PLUS",
          
        
      
        

          

            

            
              
            

              "MINUS",
          
        
      
        

          

            

            
              
            

              "ASTERISK",
          
        
      
        

          

            

            
              
            

              "SLASH",
          
        
      
        

          

            

            
              
            

              "PARENL",
          
        
      
        

          

            

            
              
            

              "PARENR",
          
        
      
        

          

            

            
              
            

              "$start",
          
        
      
        

          

            

            
              
            

              "add",
          
        
      
        

          

            

            
              
            

              "mul",
          
        
      
        

          

            

            
              
            

              "unary",
          
        
      
        

          

            

            
              
            

              "round_type",
          
        
      
        

          

            

            
              
            

              "term" ]
          
        
      
        

          

            
              1
            

            
              
                
                  then: 1
                
              
                
                  else: 0
                
              
            

            Ractor.make_shareable(Racc_token_to_s_table) if defined?(Ractor)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            Racc_debug_parser = false
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            ##### State transition tables end #####
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # reduce 0 omitted
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def _reduce_1(val, _values, result)
          
        
      
        

          

            
              376
            

            
              
            

             result = Arithmetic::Node::BinaryOp.new(val[0], :+, val[2])
          
        
      
        

          

            
              376
            

            
              
            

                result
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def _reduce_2(val, _values, result)
          
        
      
        

          

            
              409
            

            
              
            

             result = Arithmetic::Node::BinaryOp.new(val[0], :-, val[2])
          
        
      
        

          

            
              409
            

            
              
            

                result
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # reduce 3 omitted
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def _reduce_4(val, _values, result)
          
        
      
        

          

            
              99
            

            
              
            

             result = Arithmetic::Node::BinaryOp.new(val[0], :*, val[2])
          
        
      
        

          

            
              99
            

            
              
            

                result
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def _reduce_5(val, _values, result)
          
        
      
        

          

            
              80
            

            
              
            

                     divied_class = val[3]
          
        
      
        

          

            
              80
            

            
              
            

                     result = divied_class.new(val[0], val[2])
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              80
            

            
              
            

                result
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # reduce 6 omitted
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def _reduce_7(val, _values, result)
          
        
      
        

          

            
              72
            

            
              
            

             result = Arithmetic::Node::DivideWithGameSystemDefault
          
        
      
        

          

            
              72
            

            
              
            

                result
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def _reduce_8(val, _values, result)
          
        
      
        

          

            
              1
            

            
              
            

             result = Arithmetic::Node::DivideWithCeil
          
        
      
        

          

            
              1
            

            
              
            

                result
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def _reduce_9(val, _values, result)
          
        
      
        

          

            
              5
            

            
              
            

             result = Arithmetic::Node::DivideWithCeil
          
        
      
        

          

            
              5
            

            
              
            

                result
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def _reduce_10(val, _values, result)
          
        
      
        

          

            
              1
            

            
              
            

             result = Arithmetic::Node::DivideWithRound
          
        
      
        

          

            
              1
            

            
              
            

                result
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def _reduce_11(val, _values, result)
          
        
      
        

          

            
              1
            

            
              
            

             result = Arithmetic::Node::DivideWithFloor
          
        
      
        

          

            
              1
            

            
              
            

                result
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def _reduce_12(val, _values, result)
          
        
      
        

          

            
              722
            

            
              
            

             result = val[1]
          
        
      
        

          

            
              722
            

            
              
            

                result
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def _reduce_13(val, _values, result)
          
        
      
        

          

            
              248
            

            
              
            

             result = Arithmetic::Node::Negative.new(val[1])
          
        
      
        

          

            
              248
            

            
              
            

                result
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # reduce 14 omitted
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def _reduce_15(val, _values, result)
          
        
      
        

          

            
              565
            

            
              
            

             result = val[1]
          
        
      
        

          

            
              565
            

            
              
            

                result
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def _reduce_16(val, _values, result)
          
        
      
        

          

            
              4026
            

            
              
            

             result = Arithmetic::Node::Number.new(val[0])
          
        
      
        

          

            
              4026
            

            
              
            

                result
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def _reduce_none(val, _values, result)
          
        
      
        

          

            

            
              
            

              val[0]
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                end   # class Parser
          
        
      
        

          

            

            
              
            

              end   # module Arithmetic
          
        
      
        

          

            

            
              
            

            end   # module BCDice
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module BCDice
          
        
      
        

          

            
              1
            

            
              
            

              module ArithmeticEvaluator
          
        
      
        

          

            
              1
            

            
              
            

                class << self
          
        
      
        

          

            

            
              
            

                  # 四則演算を評価する
          
        
      
        

          

            

            
              
            

                  # @deprecated +Arithmetic.#eval+ を利用してください。
          
        
      
        

          

            

            
              
            

                  # @param expr [String, nil] 評価する式
          
        
      
        

          

            

            
              
            

                  # @param round_type [Symbol] 端数処理の種類
          
        
      
        

          

            

            
              
            

                  # @return [Integer] 評価結果を返す。不正な式の場合には0を返す。
          
        
      
        

          

            
              1
            

            
              
            

                  def eval(expr, round_type: RoundType::FLOOR)
          
        
      
        

          

            
              2379
            

            
              
                
                  else: 2075
                
              
                
                  then: 304
                
              
            

                    return 0 unless expr
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2075
            

            
              
            

                    Arithmetic.eval(expr, round_type) || 0
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "i18n"
          
        
      
        

          

            
              1
            

            
              
            

            require "i18n/backend/fallbacks"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/randomizer"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/dice_table"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/enum"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/translate"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/result"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/command/parser"
          
        
      
        

          

            
              1
            

            
              
            

            require "bcdice/deprecated/checker"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module BCDice
          
        
      
        

          

            
              1
            

            
              
            

              class Base
          
        
      
        

          

            
              1
            

            
              
            

                class << self
          
        
      
        

          

            

            
              
            

                  # 接頭辞（反応するコマンド）の配列を返す
          
        
      
        

          

            

            
              
            

                  # @return [Array<String>]
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :prefixes
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 応答するコマンドのprefixを登録する
          
        
      
        

          

            

            
              
            

                  # @param prefixes [Array<String>]
          
        
      
        

          

            
              1
            

            
              
            

                  def register_prefix(*prefixes)
          
        
      
        

          

            
              290
            

            
              
            

                    @prefixes ||= []
          
        
      
        

          

            
              290
            

            
              
            

                    @prefixes.concat(prefixes.flatten)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def register_prefix_from_super_class
          
        
      
        

          

            
              31
            

            
              
            

                    register_prefix(superclass.prefixes)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # ゲームシステム固有のコマンドにマッチする正規表現を返す
          
        
      
        

          

            

            
              
            

                  # 正規表現を一度生成したら、以後コマンドの登録はできないようにする
          
        
      
        

          

            

            
              
            

                  #
          
        
      
        

          

            

            
              
            

                  # @return [Regexp]
          
        
      
        

          

            
              1
            

            
              
            

                  def prefixes_pattern
          
        
      
        

          

            
              17961
            

            
              
            

                    @prefixes_pattern ||= nil
          
        
      
        

          

            
              17961
            

            
              
                
                  then: 17665
                
              
                
                  else: 296
                
              
            

                    return @prefixes_pattern if @prefixes_pattern
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              296
            

            
              
            

                    @prefixes ||= []
          
        
      
        

          

            
              296
            

            
              
            

                    @prefixes.freeze
          
        
      
        

          

            

            
              
            

                    @prefixes_pattern =
          
        
      
        

          

            
              296
            

            
              
                
                  then: 30
                
              
            

                      if @prefixes.empty?
          
        
      
        

          

            
              30
            

            
              
            

                        /(?!)/ # 何にもマッチしない正規表現
          
        
      
        

          

            

            
              
                
                  else: 266
                
              
            

                      else
          
        
      
        

          

            
              266
            

            
              
            

                        /^(S)?(#{@prefixes.join('|')})/i
          
        
      
        

          

            

            
              
            

                      end.freeze
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 応答するコマンド全てにマッチする正規表現を返す
          
        
      
        

          

            

            
              
            

                  # 正規表現を一度生成したら、以後コマンドの登録はできないようにする
          
        
      
        

          

            

            
              
            

                  #
          
        
      
        

          

            

            
              
            

                  # @return [Regexp]
          
        
      
        

          

            
              1
            

            
              
            

                  def command_pattern
          
        
      
        

          

            
              17519
            

            
              
            

                    @command_pattern ||= nil
          
        
      
        

          

            
              17519
            

            
              
                
                  then: 17227
                
              
                
                  else: 292
                
              
            

                    return @command_pattern if @command_pattern
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              292
            

            
              
            

                    @prefixes ||= []
          
        
      
        

          

            
              292
            

            
              
            

                    @prefixes.freeze
          
        
      
        

          

            
              3212
            

            
              
            

                    pattarns = CommonCommand::COMMANDS.map { |c| c::PREFIX_PATTERN.source } + @prefixes
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              292
            

            
              
            

                    @command_pattern = /^S?(#{pattarns.join('|')})/i.freeze
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # @param command [String]
          
        
      
        

          

            

            
              
            

                  # @return [Result]
          
        
      
        

          

            
              1
            

            
              
            

                  def eval(command)
          
        
      
        

          

            
              13
            

            
              
            

                    new(command).eval
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                include Translate
          
        
      
        

          

            
              1
            

            
              
            

                include Deprecated::Checker
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def initialize(command)
          
        
      
        

          

            
              17970
            

            
              
            

                  @raw_input = command
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17970
            

            
              
            

                  @sort_add_dice = false # 加算ダイスでダイス目をソートするかどうか
          
        
      
        

          

            
              17970
            

            
              
            

                  @sort_barabara_dice = false # バラバラダイスでダイス目をソートするかどうか
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17970
            

            
              
            

                  @d66_sort_type = D66SortType::NO_SORT # 入れ替えの種類 詳しくはBCDice::D66SortTypeを参照すること
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17970
            

            
              
            

                  @enabled_d9 = false # D9ダイスを有効にするか（ガンドッグ）で使用
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17970
            

            
              
            

                  @round_type = RoundType::FLOOR # 割り算をした時の端数の扱い (FLOOR: 切り捨て, CEIL: 切り上げ, ROUND: 四捨五入)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17970
            

            
              
            

                  @sides_implicit_d = 6 # 1D のようにダイスの面数が指定されていない場合に何面ダイスにするか
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17970
            

            
              
            

                  @upper_dice_reroll_threshold = nil # UpperDiceで振り足しをする出目の閾値 nilの場合デフォルト設定なし
          
        
      
        

          

            
              17970
            

            
              
            

                  @reroll_dice_reroll_threshold = nil # RerollDiceで振り足しをする出目の閾値 nilの場合デフォルト設定なし
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17970
            

            
              
            

                  @default_cmp_op = nil # 目標値が空欄の場合の比較演算子をシンボルで指定する (:>, :>= :<, :<=, :==, :!=)
          
        
      
        

          

            
              17970
            

            
              
            

                  @default_target_number = nil # 目標値が空欄の場合の目標値 こちらだけnilにするのは想定していないので注意
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17970
            

            
              
            

                  @enabled_upcase_input = true # 入力を String#upcase するかどうか
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17970
            

            
              
            

                  @locale = :ja_jp # i18n用の言語設定
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17970
            

            
              
            

                  @randomizer = BCDice::Randomizer.new
          
        
      
        

          

            
              17970
            

            
              
            

                  @debug = false
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_accessor :randomizer
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # D66のダイス入れ替えの種類
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # @return [Symbol]
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :d66_sort_type
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 端数処理の種類
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # @return [Symbol]
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :round_type
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # ダイスの面数が指定されていない場合に何面ダイスにするか
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # @return [Integer]
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :sides_implicit_d
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # UpperDiceで振り足しをする出目の閾値
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # @return [Integer, nil]
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :upper_dice_reroll_threshold
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # RerollDiceで振り足しをする出目の閾値
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # @return [Integer, nil]
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :reroll_dice_reroll_threshold
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # デフォルトの比較演算子
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # @return [Symbol, nil]
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :default_cmp_op
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # デフォルトの目標値
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # @return [Integer, nil]
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :default_target_number
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 加算ダイスでダイス目をソートするかどうか
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # @return [Boolean]
          
        
      
        

          

            
              1
            

            
              
            

                def sort_add_dice?
          
        
      
        

          

            
              1261
            

            
              
            

                  @sort_add_dice
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # バラバラダイスでダイス目をソートするかどうか
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # @return [Boolean]
          
        
      
        

          

            
              1
            

            
              
            

                def sort_barabara_dice?
          
        
      
        

          

            
              268
            

            
              
            

                  @sort_barabara_dice
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # D9ダイスが有効か
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # @return [Boolean]
          
        
      
        

          

            
              1
            

            
              
            

                def enabled_d9?
          
        
      
        

          

            
              4
            

            
              
            

                  @enabled_d9
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # デバッグを有用にする
          
        
      
        

          

            
              1
            

            
              
            

                def enable_debug
          
        
      
        

          

            

            
              
            

                  @debug = true
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # コマンドを評価する
          
        
      
        

          

            

            
              
            

                # @return [Result, nil] コマンド実行結果。コマンドが実行できなかった場合はnilを返す
          
        
      
        

          

            
              1
            

            
              
            

                def eval
          
        
      
        

          

            
              17961
            

            
              
            

                  command = BCDice::Preprocessor.process(@raw_input, self)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17961
            

            
              
            

                  result = dice_command(command) || eval_common_command(@raw_input)
          
        
      
        

          

            
              17959
            

            
              
                
                  else: 17746
                
              
                
                  then: 213
                
              
            

                  return nil unless result
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17746
            

            
              
            

                  result.rands = @randomizer.rand_results
          
        
      
        

          

            
              17746
            

            
              
            

                  result.detailed_rands = @randomizer.detailed_rand_results
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17746
            

            
              
            

                  return result
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # ゲームシステムごとの入力コマンドの前処理
          
        
      
        

          

            

            
              
            

                # @deprecated これを使わずに +eval_common_command+ 内でパースすることを推奨する
          
        
      
        

          

            

            
              
            

                # @param string [String]
          
        
      
        

          

            

            
              
            

                # @return [String]
          
        
      
        

          

            
              1
            

            
              
            

                def change_text(string)
          
        
      
        

          

            
              19588
            

            
              
            

                  string
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # @param total [Integer] コマンド合計値
          
        
      
        

          

            

            
              
            

                # @param rand_results [Array<CommonCommand::AddDice::Randomizer::RandResult>] ダイスの一覧
          
        
      
        

          

            

            
              
            

                # @param cmp_op [Symbol] 比較演算子
          
        
      
        

          

            

            
              
            

                # @param target [Integer, String] 目標値の整数か'?'
          
        
      
        

          

            

            
              
            

                # @return [Result, nil]
          
        
      
        

          

            
              1
            

            
              
            

                def check_result(total, rand_results, cmp_op, target)
          
        
      
        

          

            
              811
            

            
              
            

                  ret = check_result_legacy(total, rand_results, cmp_op, target)
          
        
      
        

          

            
              811
            

            
              
                
                  then: 13
                
              
                
                  else: 798
                
              
            

                  return ret if ret
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              798
            

            
              
            

                  sides_list = rand_results.map(&:sides)
          
        
      
        

          

            
              798
            

            
              
            

                  value_list = rand_results.map(&:value)
          
        
      
        

          

            
              798
            

            
              
            

                  dice_total = value_list.sum()
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  ret =
          
        
      
        

          

            
              798
            

            
              
                
                  else: 165
                
              
            

                    case sides_list
          
        
      
        

          

            

            
              
                
                  when: 257
                
              
            

                    when [100]
          
        
      
        

          

            
              257
            

            
              
            

                      result_1d100(total, dice_total, cmp_op, target)
          
        
      
        

          

            

            
              
                
                  when: 62
                
              
            

                    when [20]
          
        
      
        

          

            
              62
            

            
              
            

                      result_1d20(total, dice_total, cmp_op, target)
          
        
      
        

          

            

            
              
                
                  when: 314
                
              
            

                    when [6, 6]
          
        
      
        

          

            
              314
            

            
              
            

                      result_2d6(total, dice_total, value_list, cmp_op, target)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              798
            

            
              
                
                  then: 18
                
              
                
                  else: 780
                
              
            

                  return nil if ret == Result.nothing
          
        
      
        

          

            
              780
            

            
              
                
                  then: 430
                
              
                
                  else: 350
                
              
            

                  return ret if ret
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  ret =
          
        
      
        

          

            
              350
            

            
              
                
                  else: 60
                
              
            

                    case sides_list.uniq
          
        
      
        

          

            

            
              
                
                  when: 52
                
              
            

                    when [10]
          
        
      
        

          

            
              52
            

            
              
            

                      result_nd10(total, dice_total, value_list, cmp_op, target)
          
        
      
        

          

            

            
              
                
                  when: 238
                
              
            

                    when [6]
          
        
      
        

          

            
              238
            

            
              
            

                      result_nd6(total, dice_total, value_list, cmp_op, target)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              350
            

            
              
                
                  then: 4
                
              
                
                  else: 346
                
              
            

                  return nil if ret == Result.nothing
          
        
      
        

          

            
              346
            

            
              
                
                  then: 149
                
              
                
                  else: 197
                
              
            

                  return ret if ret
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              197
            

            
              
            

                  return result_ndx(total, cmp_op, target)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # シャドウラン用グリッチ判定
          
        
      
        

          

            

            
              
            

                # @param count_one [Integer] 出目1の数
          
        
      
        

          

            

            
              
            

                # @param dice_total_count [Integer] ダイスロールしたダイスの数
          
        
      
        

          

            

            
              
            

                # @param count_success [Integer] 成功数
          
        
      
        

          

            

            
              
            

                # @return [String, nil]
          
        
      
        

          

            
              1
            

            
              
            

                def grich_text(count_one, dice_total_count, count_success); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def eval_common_command(command)
          
        
      
        

          

            
              1819
            

            
              
            

                  command = change_text(command)
          
        
      
        

          

            
              1819
            

            
              
            

                  CommonCommand::COMMANDS.each do |klass|
          
        
      
        

          

            
              5706
            

            
              
            

                    result = klass.eval(command, self, @randomizer)
          
        
      
        

          

            
              5704
            

            
              
                
                  then: 1604
                
              
                
                  else: 4100
                
              
            

                    return result if result
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              213
            

            
              
            

                  return nil
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def dice_command(command)
          
        
      
        

          

            
              17961
            

            
              
                
                  then: 17860
                
              
                
                  else: 101
                
              
            

                  command = command.upcase if @enabled_upcase_input
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17961
            

            
              
            

                  m = self.class.prefixes_pattern.match(command)
          
        
      
        

          

            
              17961
            

            
              
                
                  else: 16329
                
              
                
                  then: 1632
                
              
            

                  unless m
          
        
      
        

          

            
              1632
            

            
              
            

                    return nil
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              16329
            

            
              
            

                  secret = !m[1].nil?
          
        
      
        

          

            
              16329
            

            
              
                
                  then: 473
                
              
                
                  else: 15856
                
              
            

                  command = command[1..-1] if secret # 先頭の 'S' をとる
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              16329
            

            
              
            

                  output = eval_game_system_specific_command(command)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              16329
            

            
              
                
                  then: 4880
                
              
            

                  if output.is_a?(Result)
          
        
      
        

          

            
              4880
            

            
              
            

                    output.secret = output.secret? || secret
          
        
      
        

          

            
              4880
            

            
              
                
                  else: 11449
                
              
            

                    return output
          
        
      
        

          

            
              11449
            

            
              
                
                  then: 186
                
              
            

                  elsif output.nil? || output.empty? || output == "1"
          
        
      
        

          

            
              186
            

            
              
            

                    return nil
          
        
      
        

          

            

            
              
                
                  else: 11263
                
              
            

                  else
          
        
      
        

          

            
              11263
            

            
              
            

                    return Result.new.tap do |r|
          
        
      
        

          

            
              11263
            

            
              
            

                      r.text = output.to_s
          
        
      
        

          

            
              11263
            

            
              
            

                      r.secret = secret
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # @param command [String]
          
        
      
        

          

            

            
              
            

                # @return [String, nil]
          
        
      
        

          

            
              1
            

            
              
            

                def eval_game_system_specific_command(command); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 成功か失敗か返す
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # @param total [Integer]
          
        
      
        

          

            

            
              
            

                # @param cmp_op [Symbol]
          
        
      
        

          

            

            
              
            

                # @param target [Number]
          
        
      
        

          

            

            
              
            

                # @return [Result]
          
        
      
        

          

            
              1
            

            
              
            

                def result_ndx(total, cmp_op, target)
          
        
      
        

          

            
              197
            

            
              
                
                  then: 44
                
              
            

                  if target.is_a?(String)
          
        
      
        

          

            
              44
            

            
              
                
                  else: 153
                
              
            

                    nil
          
        
      
        

          

            
              153
            

            
              
                
                  then: 93
                
              
            

                  elsif total.send(cmp_op, target)
          
        
      
        

          

            
              93
            

            
              
            

                    Result.success(translate("success"))
          
        
      
        

          

            

            
              
                
                  else: 60
                
              
            

                  else
          
        
      
        

          

            
              60
            

            
              
            

                    Result.failure(translate("failure"))
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def result_1d100(total, dice_total, cmp_op, target); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def result_1d20(total, dice_total, cmp_op, target); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def result_nd10(total, dice_total, value_list, cmp_op, target); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def result_2d6(total, dice_total, value_list, cmp_op, target); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def result_nd6(total, dice_total, value_list, cmp_op, target); end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def get_table_by_2d6(table)
          
        
      
        

          

            
              241
            

            
              
            

                  get_table_by_nD6(table, 2)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def get_table_by_1d6(table)
          
        
      
        

          

            
              154
            

            
              
            

                  get_table_by_nD6(table, 1)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def get_table_by_nD6(table, count)
          
        
      
        

          

            
              400
            

            
              
            

                  get_table_by_nDx(table, count, 6)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def get_table_by_nDx(table, count, diceType)
          
        
      
        

          

            
              410
            

            
              
            

                  num = @randomizer.roll_sum(count, diceType)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              410
            

            
              
            

                  text = get_table_value(table[num - count])
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              410
            

            
              
                
                  then: 0
                
              
                
                  else: 410
                
              
            

                  return "1", 0 if text.nil?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              410
            

            
              
            

                  return text, num
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def get_table_by_1d3(table)
          
        
      
        

          

            
              10
            

            
              
            

                  debug("get_table_by_1d3")
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
            

                  count = 1
          
        
      
        

          

            
              10
            

            
              
            

                  num = @randomizer.roll_sum(count, 6)
          
        
      
        

          

            
              10
            

            
              
            

                  debug("num", num)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
            

                  index = ((num - 1) / 2)
          
        
      
        

          

            
              10
            

            
              
            

                  debug("index", index)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
            

                  text = table[index]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
                
                  then: 0
                
              
                
                  else: 10
                
              
            

                  return "1", 0 if text.nil?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
            

                  return text, num
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # D66 ロール用（スワップ、たとえば出目が【６，４】なら「６４」ではなく「４６」とする
          
        
      
        

          

            
              1
            

            
              
            

                def get_table_by_d66_swap(table)
          
        
      
        

          

            
              85
            

            
              
            

                  number = @randomizer.roll_d66(D66SortType::ASC)
          
        
      
        

          

            
              85
            

            
              
            

                  return get_table_by_number(number, table), number
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # D66 ロール用
          
        
      
        

          

            
              1
            

            
              
            

                def get_table_by_d66(table)
          
        
      
        

          

            
              158
            

            
              
            

                  dice1 = @randomizer.roll_once(6)
          
        
      
        

          

            
              158
            

            
              
            

                  dice2 = @randomizer.roll_once(6)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              158
            

            
              
            

                  num = (dice1 - 1) * 6 + (dice2 - 1)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              158
            

            
              
            

                  text = table[num]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              158
            

            
              
            

                  indexText = "#{dice1}#{dice2}"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              158
            

            
              
                
                  then: 0
                
              
                
                  else: 158
                
              
            

                  return "1", indexText if text.nil?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              158
            

            
              
            

                  return text, indexText
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # ** 汎用表サブルーチン
          
        
      
        

          

            
              1
            

            
              
            

                def get_table_by_number(index, table, default = "1")
          
        
      
        

          

            
              1938
            

            
              
            

                  table.each do |item|
          
        
      
        

          

            
              13653
            

            
              
            

                    number = item[0]
          
        
      
        

          

            
              13653
            

            
              
                
                  then: 1938
                
              
                
                  else: 11715
                
              
            

                    if number >= index
          
        
      
        

          

            
              1938
            

            
              
            

                      return get_table_value(item[1])
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  return get_table_value(default)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def get_table_value(data)
          
        
      
        

          

            
              2348
            

            
              
                
                  then: 446
                
              
                
                  else: 1902
                
              
            

                  if data.is_a?(Proc)
          
        
      
        

          

            
              446
            

            
              
            

                    return data.call()
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1902
            

            
              
            

                  return data
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def roll_tables(command, tables)
          
        
      
        

          

            
              4490
            

            
              
            

                  table = tables[command]
          
        
      
        

          

            
              4490
            

            
              
                
                  else: 3548
                
              
                
                  then: 942
                
              
            

                  unless table
          
        
      
        

          

            
              942
            

            
              
            

                    return nil
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              3548
            

            
              
            

                  return table.roll(@randomizer).to_s
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # デバッグ出力を行う
          
        
      
        

          

            

            
              
            

                # @param [Object] target 対象項目
          
        
      
        

          

            

            
              
            

                # @param [Object] values 値
          
        
      
        

          

            
              1
            

            
              
            

                def debug(target, *values)
          
        
      
        

          

            
              23439
            

            
              
                
                  else: 0
                
              
                
                  then: 23439
                
              
            

                  return unless @debug
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  targetStr = target.is_a?(String) ? target : target.inspect
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
            

                  if values.empty?
          
        
      
        

          

            

            
              
            

                    warn targetStr
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                  else
          
        
      
        

          

            

            
              
            

                    valueStrs = values.map do |value|
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                      value.is_a?(String) ? %("#{value}") : value.inspect
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    warn "#{targetStr}: #{valueStrs.join(', ')}"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            I18n::Backend::Simple.include(I18n::Backend::Fallbacks)
          
        
      
        

          

            
              1
            

            
              
            

            I18n.load_path << Dir[File.join(__dir__, "../../i18n/**/*.yml")]
          
        
      
        

          

            
              1
            

            
              
            

            I18n.default_locale = :ja_jp
          
        
      
        

          

            
              1
            

            
              
            

            I18n.fallbacks.defaults = [:ja_jp]